Wikibooks plwikibooks https://pl.wikibooks.org/wiki/Wikibooks:Strona_g%C5%82%C3%B3wna MediaWiki 1.46.0-wmf.21 first-letter Media Specjalna Dyskusja Wikipedysta Dyskusja wikipedysty Wikibooks Dyskusja Wikibooks Plik Dyskusja pliku MediaWiki Dyskusja MediaWiki Szablon Dyskusja szablonu Pomoc Dyskusja pomocy Kategoria Dyskusja kategorii Wikijunior Dyskusja Wikijuniora TimedText TimedText talk Moduł Dyskusja modułu Wydarzenie Dyskusja wydarzenia 828 45669 538503 538416 2026-03-29T13:40:32Z Persino 2851 538503 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"); return parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](frame:getParent().args,frame.args["niepuste"]); 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 nil; else i=i+1; end; end; end; end; if((czy)or(i==1))then return "tak";else return;end; 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 (type(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) return frame and (p.TypeTable(frame) and (p.PobierzFrameEwentualnieParent(frame).args or frame) or ((czy_nie_tablica_jako_tablica)and {frame,} or frame)) or {}; end; function p.PobierzParametryRamki(frame) local TempFun1=function(tablica) return function(nazwa) return tablica[nazwa]; end; end; local TempFun2=function(tablica) local tak=true; return function(nazwa) local wartosc=tak and tablica or nil; tak=false; return wartosc; 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(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) local wartosc=tak and frame or nil; tak=false; return wartosc,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; 2u0z7fo10p25737lkt8e3xiiep8tqd2 538539 538503 2026-03-29T16:53:50Z Persino 2851 538539 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"); return parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](frame:getParent().args,frame.args["niepuste"]); 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 nil; else i=i+1; end; end; end; end; if((czy)or(i==1))then return "tak";else return;end; 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 (type(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) return (not p.TypeNil(frame)) and (p.TypeTable(frame) and (p.PobierzFrameEwentualnieParent(frame).args or frame) or ((czy_nie_tablica_jako_tablica)and {frame,} or frame)) or {}; end; function p.PobierzParametryRamki(frame) local TempFun1=function(tablica) return function(nazwa) return tablica[nazwa]; end; end; local TempFun2=function(tablica) local tak=true; return function(nazwa) local wartosc=tak and tablica or nil; tak=false; return wartosc; 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(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) local wartosc=tak and frame or nil; tak=false; return wartosc,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; 7npu3ch68p21p8tkjdigids8ns6fdi1 538543 538539 2026-03-29T19:23:00Z Persino 2851 538543 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"); return parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](frame:getParent().args,frame.args["niepuste"]); 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 nil; else i=i+1; end; end; end; end; if((czy)or(i==1))then return "tak";else return;end; 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) return (not p.TypeNil(frame)) and (p.TypeTable(frame) and (p.PobierzFrameEwentualnieParent(frame).args or frame) or ((czy_nie_tablica_jako_tablica)and {frame,} or frame)) or {}; 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(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) local wartosc=tak and frame or nil; tak=false; return wartosc,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; g3sngetkwafvp8o9yvt36vzgywgnl5f 538566 538543 2026-03-30T05:49:03Z Persino 2851 538566 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"); return parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](frame:getParent().args,frame.args["niepuste"]); 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 nil; else i=i+1; end; end; end; end; if((czy)or(i==1))then return "tak";else return;end; 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) return (not p.TypeNil(frame)) and (p.TypeTable(frame) and (p.PobierzFrameEwentualnieParent(frame).args or frame) or ((czy_nie_tablica_jako_tablica)and {frame,} or frame)) or {}; 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(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; tr6d78ywusblnz8swjsvxa0m7zz7jf5 538567 538566 2026-03-30T06:09:03Z Persino 2851 538567 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"); return parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](frame:getParent().args,frame.args["niepuste"]); 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 nil; else i=i+1; end; end; end; end; if((czy)or(i==1))then return "tak";else return;end; 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) return (not p.TypeNil(frame)) and (p.TypeTable(frame) and (p.PobierzFrameEwentualnieParent(frame).args or frame) or ((czy_nie_tablica_jako_tablica)and {frame,} or frame)) or {}; 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; c4sg9u9ze4tqoy5n9fskwyziwib5fiy 538568 538567 2026-03-30T06:31:34Z Persino 2851 538568 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"); return parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](frame:getParent().args,frame.args["niepuste"]); 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 nil; else i=i+1; end; end; end; end; if((czy)or(i==1))then return "tak";else return;end; 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; return (not p.TypeNil(frame)) and (p.TypeTable(frame) and (TempFunc(frame) or frame) or ((czy_nie_tablica_jako_tablica)and {frame,} or frame)) or {}; 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; lj1wcepv67x70pnuw5h1f2emtg90dx0 538575 538568 2026-03-30T07:16:52Z Persino 2851 538575 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"); return parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](frame:getParent().args,frame.args["niepuste"]); 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 nil; else i=i+1; end; end; end; end; if((czy)or(i==1))then return "tak";else return;end; 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; bkev9goyaz2m1zmkwv1cwsef597dypt 104 57531 538521 537879 2026-03-29T15:22:49Z Igor123121 34732 /* Polskie wynalazki */ 538521 wikitext text/x-wiki =Spis treści= *[[Wikijunior:Polska|Strona główna]] *[[Wikijunior:Polska/Wstęp|Wstęp]] *[[Wikijunior:Polska/Informacje|Ogólne informacje o Polsce]] ---- ==Ustrój i prawo Polski== *[[Wikijunior:Polska/Ustrój|Ustrój]] *[[Wikijunior:Polska/Konstytucja Rzeczypospolitej Polskiej|Konstytucja Rzeczypospolitej Polskiej]] *[[Wikijunior:Polska/Samorząd terytorialny|Samorząd terytorialny]] ===Symbole i święta=== *[[Wikijunior:Polska/Symbole Narodowe|Symbole narodowe Polski]] *[[Wikijunior:Polska/Znaczenie Hymnu|Znaczenie hymnu]] *[[Wikijunior:Polska/Godło Rzeczypospolitej Polskiej|Godło Polski]] *[[Wikijunior:Polska/Święta państwowe|Święta państwowe]] *[[Wikijunior:Polska/Dni wolne od pracy|Dni wolne od pracy]] ===Organy władz centralnych w Polsce=== * [[Wikijunior:Polska/Prezydent Rzeczypospolitej Polskiej|Prezydent Rzeczypospolitej Polskiej]] * [[Wikijunior:Polska/Marszałek Sejmu Rzeczypospolitej Polskiej|Marszałek Sejmu Rzeczypospolitej Polskiej]] * [[Wikijunior:Polska/Prezes Rady Ministrów|Prezes Rady Ministrów]] * [[Wikijunior:Polska/Minister|Minister]] * [[Wikijunior:Polska/Poseł na Sejm|Poseł na Sejm]] * [[Wikijunior:Polska/Senator|Senator]] * [[Wikijunior:Polska/Rada Gabinetowa|Rada Gabinetowa]] * [[Wikijunior:Polska/Rzecznik Praw Dziecka|Rzecznik Praw Dziecka]] * [[Wikijunior:Polska/Rzecznik Praw Obywatelskich|Rzecznik Praw Obywatelskich]] * [[Wikijunior:Polska/Najwyższa Izba Kontroli|Najwyższa Izba Kontroli]] * [[Wikijunior:Polska/Rada Mediów Narodowych|Rada Mediów Narodowych]] * [[Wikijunior:Polska/Krajowa Rada Radiofonii i Telewizji|Krajowa Rada Radiofonii i Telewizji]] === Wymiar sprawiedliwości === * [[Wikijunior:Polska/Sędziowie w Polsce|Sędziowie w Polsce]] * [[Wikijunior:Polska/Sąd Najwyższy|Sąd Najwyższy]] * [[Wikijunior:Polska/Sąd Rejonowy|Sąd Rejonowy]] * [[Wikijunior:Polska/Trybunał Stanu|Trybunał Stanu]] * [[Wikijunior:Polska/Trybunał Konstytucyjny|Trybunał Konstytucyjny]] ==Historia Polski== *[[Wikijunior:Polska/Historia|Historia]] *[[Wikijunior:Polska/Słowianie|Słowianie]] *[[Wikijunior:Polska/Chrzest Polski|Chrzest Polski]] *[[Wikijunior:Polska/Pierwsi Piastowie|Pierwsi Piastowie]] *[[Wikijunior:Polska/Rozbicie dzielnicowe|Rozbicie dzielnicowe]] *[[Wikijunior:Polska/Ostatni Piastowie - Władysław Łokietko i Kazimierz Wielki|Ostatni Piastowie - Władysław Łokietko i Kazimierz Wielki]] *[[Wikijunior:Polska/Andegawenowie|Andegawenowie]] *[[Wikijunior:Polska/Władysław Jagiełło|Władysław Jagiełło]] *[[Wikijunior:Polska/Jagiellonowie|Jagiellonowie]] *[[Wikijunior:Polska/Królowie elekcyjni|Królowie elekcyjni]] *[[Wikijunior:Polska/Konstytucja 3-go maja|Konstytucja Trzeciego Maja]] *[[Wikijunior:Polska/Rozbiory|Rozbiory]] *[[Wikijunior:Polska/Polska pod zaborami|Polska pod zaborami]] *[[Wikijunior:Polska/Dwudziestolecie międzywojenne|Dwudziestolecie międzywojenne]] *[[Wikijunior:Polska/Druga wojna światowa|Druga wojna światowa]] *[[Wikijunior:Polska/PRL|PRL]] *[[Wikijunior:Polska/Okrągły Stół|Okrągły Stół]] *[[Wikijunior:Polska/Wstąpienie Polski do Unii Europejskiej|Wstąpienie Polski do Unii Europejskiej]] ===Legendy Polskie=== *[[Wikijunior:Polska/Legenda o powstaniu kraju|Legenda o powstaniu kraju]] *[[Wikijunior:Polska/Legenda o dwóch wieżach Kościoła Mariackiego|Legenda o dwóch wieżach Kościoła Mariackiego]] *[[Wikijunior:Polska/Legenda o zaczarowanych gołębiach krakowskich|Legenda o zaczarowanych gołębiach krakowskich]] ==Geografia Polski== ===Geografia fizyczna=== *[[Wikijunior:Polska/Ranking geograficzny|Rekordy geograficzne]] ====Rzeki==== *[[Wikijunior:Polska/Wisła|Wisła]] *[[Wikijunior:Polska/Odra|Odra]] *[[Wikijunior:Polska/Warta|Warta]] *[[Wikijunior:Polska/Bug|Bug]] *[[Wikijunior:Polska/Narew|Narew]] ====Regiony geograficzne==== *[[Wikijunior:Polska/Bałtyk|Bałtyk]] *[[Wikijunior:Polska/Pobrzeża|Pobrzeża]] *[[Wikijunior:Polska/Pojezierza|Pojezierza]] *[[Wikijunior:Polska/Niziny|Niziny]] *[[Wikijunior:Polska/Wyżyny|Wyżyny]] *[[Wikijunior:Polska/Jura Krakowsko-Częstochowska|Jura Krakowsko-Częstochowska]] *[[Wikijunior:Polska/Góry Świętokrzyskie|Góry Świętokrzyskie]] *[[Wikijunior:Polska/Sudety|Sudety]] *[[Wikijunior:Polska/Karpaty|Karpaty]] ===Geografia społeczna=== ====Regiony Polski==== *[[Wikijunior:Polska/Kujawy|Kujawy]] *[[Wikijunior:Polska/Małopolska|Małopolska]] *[[Wikijunior:Polska/Mazowsze|Mazowsze]] *[[Wikijunior:Polska/Mazury|Mazury]] *[[Wikijunior:Polska/Podlasie|Podlasie]] *[[Wikijunior:Polska/Pomorze|Pomorze]] *[[Wikijunior:Polska/Śląsk|Śląsk]] *[[Wikijunior:Polska/Wielkopolska|Wielkopolska]] *[[Wikijunior:Polska/Warmia|Warmia]] =====Województwa===== *[[Wikijunior:Polska/Dolnośląskie|Dolnośląskie]] *[[Wikijunior:Polska/Kujawsko-pomorskie|Kujawsko-pomorskie]] *[[Wikijunior:Polska/Lubelskie|Lubelskie]] *[[Wikijunior:Polska/Lubuskie|Lubuskie]] *[[Wikijunior:Polska/Łódzkie|Łódzkie]] *[[Wikijunior:Polska/Małopolskie|Małopolskie]] *[[Wikijunior:Polska/Mazowieckie|Mazowieckie]] *[[Wikijunior:Polska/Opolskie|Opolskie]] *[[Wikijunior:Polska/Podkarpackie|Podkarpackie]] *[[Wikijunior:Polska/Podlaskie|Podlaskie]] *[[Wikijunior:Polska/Pomorskie|Pomorskie]] *[[Wikijunior:Polska/Śląskie|Śląskie]] *[[Wikijunior:Polska/Świętokrzyskie|Świętokrzyskie]] *[[Wikijunior:Polska/Warmińsko-mazurskie|Warmińsko-mazurskie]] *[[Wikijunior:Polska/Wielkopolskie|Wielkopolskie]] *[[Wikijunior:Polska/Zachodniopomorskie|Zachodniopomorskie]] =====Miasta===== *[[Wikijunior:Polska/Miasta|Miasta]] *[[Wikijunior:Polska/Warszawa|Warszawa]] *[[Wikijunior:Polska/Kraków|Kraków]] *[[Wikijunior:Polska/Gdańsk|Gdańsk]] *[[Wikijunior:Polska/Łódź|Łódź]] *[[Wikijunior:Polska/Wrocław|Wrocław]] *[[Wikijunior:Polska/Poznań|Poznań]] *[[Wikijunior:Polska/Szczecin|Szczecin]] *[[Wikijunior:Polska/Katowice|Katowice]] =====Demografia===== *[[Wikijunior:Polska/Ludność|Ludność]] *[[Wikijunior:Polska/Narodowości|Narodowości]] *[[Wikijunior:Polska/Języki, gwary i dialekty|Języki, gwary i dialekty]] *[[Wikijunior:Polska/Struktura płci i wieku|Struktura płci i wieku]] *[[Wikijunior:Polska/Religie i wyznania|Religie i wyznania]] ==Przyroda== *[[Wikijunior:Polska/Parki narodowe|Parki narodowe]] ==Tradycje== *[[Wikijunior:Polska/Tradycje|Tradycje]] ===Tradycje świąteczne i sezonowe=== *[[Wikijunior:Polska/Trzech Króli|Trzech Króli]] *[[Wikijunior:Polska/Tłusty czwartek|Tłusty czwartek]] *[[Wikijunior:Polska/Śledzik|Śledzik]] *[[Wikijunior:Polska/Topienie marzanny|Topienie marzanny]] *[[Wikijunior:Polska/Niedziela palmowa|Niedziela palmowa]] *[[Wikijunior:Polska/Wielkanoc|Wielkanoc]] *[[Wikijunior:Polska/Boże Ciało|Boże Ciało]] *[[Wikijunior:Polska/Dożynki|Dożynki]] *[[Wikijunior:Polska/Wszystkich Świętych|Wszystkich Świętych]] *[[Wikijunior:Polska/Adwent|Adwent]] *[[Wikijunior:Polska/Boże Narodzenie|Boże Narodzenie]] ===Inne tradycje=== *[[Wikijunior:Polska/Stroje ludowe|Stroje ludowe]] *[[Wikijunior:Polska/Kuchnia polska|Kuchnia polska]] *[[Wikijunior:Polska/Powiedzenia i przesądy|Powiedzenia i przesądy]] *[[Wikijunior:Polska/Sztuka ludowa|Sztuka ludowa]] ==Zabytki== ==Wielcy Polacy== ===Naukowcy, wynalazcy i odkrywcy=== *[[Wikijunior:Polska/Mikołaj Kopernik|Mikołaj Kopernik]] *[[Wikijunior:Polska/Maria Skłodowska-Curie|Maria Skłodowska-Curie]] *[[Wikijunior:Polska/Ludwik Zamenhof|Ludwik Zamenhof]] *[[Wikijunior:Polska/Ignacy Łukasiewicz|Ignacy Łukasiewicz]] *[[Wikijunior:Polska/Mirosław Hermaszewski|Mirosław Hermaszewski]] ===Dowódcy i politycy=== *[[Wikijunior:Polska/Tadeusz Kościuszko|Tadeusz Kościuszko]] *[[Wikijunior:Polska/Józef Piłsudski|Józef Piłsudski]] *[[Wikijunior:Polska/Lech Wałęsa|Lech Wałęsa]] ===Postaci religijne=== *[[Wikijunior:Polska/Jan Paweł II|Jan Paweł II]] ===Pisarze i artyści=== *[[Wikijunior:Polska/Adam Mickiewicz|Adam Mickiewicz]] *[[Wikijunior:Polska/Juliusz Słowacki|Juliusz Słowacki]] *[[Wikijunior:Polska/Henryk Sienkiewicz|Henryk Sienkiewicz]] *[[Wikijunior:Polska/Ignacy Krasicki|Ignacy Krasicki]] *[[Wikijunior:Polska/Jan Kochanowski|Jan Kochanowski]] *[[Wikijunior:Polska/Jan Matejko|Jan Matejko]] *[[Wikijunior:Polska/Fryderyk Chopin|Fryderyk Chopin]] ===Wielcy sportowcy=== *[[Wikijunior:Polska/Robert Lewandowski|Robert Lewandowski]] *[[Wikijunior:Polska/Iga Świątek|Iga Świątek]] *[[Wikijunior:Polska/Adam Małysz|Adam Małysz]] *[[Wikijunior:Polska/Kamil Stoch|Kamil Stoch]] *[[Wikijunior:Polska/Justyna Kowalczyk|Justyna Kowalczyk]] *[[Wikijunior:Polska/Anita Włodarczyk|Anita Włodarczyk]] ===Inni=== *[[Wikijunior:Polska/Janusz Korczak|Janusz Korczak]] ==Język polski== *[[Wikijunior:Polska/Język polski|Język polski]] *[[Wikijunior:Polska/Historia języka polskiego|Historia języka polskiego]] *[[Wikijunior:Polska/Arcydzieła literatury polskiej|Arcydzieła literatury polskiej]] == Polskie wynalazki == *[[Wikijunior:Polska/Lampa naftowa|Lampa naftowa]] *[[Wikijunior:Polska/Metoda Czochralskiego|Metoda Czochralskiego]] *[[Wikijunior:Polska/Ręczny wykrywacz min|Ręczny wykrywacz min]] *[[Wikijunior:Polska/Wycieraczki samochodowe|Wycieraczki samochodowe]] *[[Wikijunior:Polska/Kamizelka kuloodporna|Kamizelka kuloodporna]] *[[Wikijunior:Polska/Szczepionka przeciw polio|Szczepionka przeciw polio]] mpvic4h3ccoq9kwxchmb5hyggr6lkmv 0 62591 538544 529084 2026-03-29T19:52:27Z 538544 wikitext text/x-wiki {{Status|+100%|Historia}} {{Spis treści}} Poniższe opracowanie ma za zadanie przedstawić problem '''prześladowań esperantystów''' na terenie [[w:III Rzesza|III Rzeszy]] i [[w:Związek Socjalistycznych Republik Radzieckich|ZSRR]] w okresie panowania [[w:Józef Stalin|Józefa Stalina]]. Autor pragnie przedstawić ten temat w formie popularnonaukowej, podpartej autentycznymi źródłami (przede wszystkim książka pt. ''[[w:Niebezpieczny język|Niebezpieczny język]]'' Ulricha Linsa oraz inne). Za wszystkie nieścisłości historyczne spowodowane brakiem obecnej wiedzy przepraszamy i zachęcamy do edytowania. == Geneza == [[w:Esperanto|Język esperanto]], opublikowany w 1887 roku przez [[w:Ludwik Zamenhof|Ludwika Zamenhofa]], jest językiem międzynarodowym, cechującym się neutralnością i stosunkowo łatwą nauką. Jego głównym celem była i jest umożliwienie komunikacji między narodami oraz promowanie pokoju i zrozumienia międzynarodowego. Początkowo esperanto zdobywało popularność przede wszystkim w środowiskach intelektualnych, wśród młodzieży oraz w ruchach [[w:socjalizm|socjalistycznych]]. Jednak pacyfistyczne i internacjonalistyczne idee języka sprawiły, że od samego początku był on przedmiotem krytyki, a jego zwolennicy – nierzadko prześladowani. Niniejsze opracowanie koncentruje się na szczególnie mało znanym okresie historii esperanta – latach 30. i 40. XX wieku. W tym czasie język Zamenhofa był postrzegany przez reżimy totalitarne jako potencjalne zagrożenie. W III Rzeszy esperanto określano mianem „języka Żydów i komunistów”, natomiast w ZSRR, po początkowej tolerancji, zostało zakazane przez [[w:Józef Stalin|Stalina]] jako narzędzie rzekomej działalności szpiegowskiej, a jego zwolennicy byli aresztowani, więzieni, wywożeni do łagrów lub rozstrzeliwani. Poniższe opracowanie ma na celu szczegółowe przedstawienie mechanizmów prześladowań esperantystów oraz ukazanie, jak niebezpieczne dla reżimów totalitarnych było samo zrzeszanie się prostych ludzi wokół idei międzynarodowej współpracy. == Prześladowania esperantystów w Nazistowskich Niemczech == Esperanto w Niemczech zyskało znaczną grupę zwolenników już na przełomie XIX i XX wieku. W okresie [[w:Republika Weimarska|Republiki Weimarskiej]] (1919–1933) ruch esperancki rozwijał się zarówno w środowiskach intelektualnych, młodzieżowych, jak i w kręgach lewicowych. Pod koniec lat 20. istniały dwie główne organizacje: Niemiecki Związek Esperantystów (Germana Esperanto-Asocio, GEA) – organizacja neutralna politycznie, pielęgnująca idee Zamenhofa – oraz Niemiecki Robotniczy Związek Esperantystów (Germana Laborista Esperanto-Asocio, GLEA), silniej związany z ruchami socjalistycznymi oraz rozwijający się prężniej. W 1930 r. GLEA liczył około 4 000 członków, a w całych Niemczech za esperantystów uważało się około 30 000 osób. Wraz z umacnianiem się ruchu nazistowskiego esperanto zaczęło być postrzegane jako wyraz internacjonalizmu – a przez ideologów nazistowskich – jako narzędzie wrogów narodu. Po 1933 roku wrogość ta została stopniowo przekształcona w systemową politykę represji. === Poglądy ideologów nazistowskich na esperanto === Ideologia [[w:Nazizm|narodowego socjalizmu]] opierała się na kulcie wodza, skrajnym nacjonalizmie oraz teorii segregacji rasowej, co stało w sprzeczności z ideą beznarodowej, międzynarodowej wspólnoty, jaką reprezentował ruch esperancki. Esperanto, jako język neutralny i pozbawiony narodowego zakorzenienia, było postrzegane jako zagrożenie dla jedności narodowej oraz dla idei „niemieckiej wspólnoty ludowej”. Początkowo zajmowanie się esperantem bywało określane jako przejaw „słabego patriotyzmu”. Z czasem jednak język ten zaczął być kojarzony z kosmopolityzmem, pacyfizmem oraz działalnością lewicową. Szczególną rolę w tej narracji odgrywał fakt żydowskiego pochodzenia twórcy języka, [[w:Ludwik Łazarz Zamenhof|Ludwika Zamenhofa]], co ułatwiało włączanie esperanta w antysemicką propagandę. Choć pojawiają się relacje mówiące o tym, że niektórzy działacze nazistowscy próbowali uczyć się esperanta w okresie przed dojściem [[w:NSDAP|NSDAP]] do władzy, nie miało to wpływu na oficjalną linię ideologiczną, która konsekwentnie traktowała ruch esperancki jako zjawisko wrogie państwu. === Wpływ ''Mein Kampf'' na ruch esperantystów w Niemczech === [[w:Adolf Hitler|Hitler]] w swojej pracy napisał: ''Tak długo póki Żyd nie jest szefem, musi mówić językiem narodu kraju, w którym mieszka. Gdy kraje będą mu podległe, wszyscy będą musieli uczyć się języka powszechnego (np. esperanto!). Za jego pomocą żydostwo będzie mogło łatwiej rządzić.'' Choć esperanto nie zajmowało w ''Mein Kampf'' miejsca centralnego, przytoczony fragment odegrał istotną rolę w późniejszej propagandzie oraz wpłynął na poglądy ideologów narodowego socjalizmu. Stał się uzasadnieniem dla przedstawiania esperanta jako narzędzia używanego przez komunistów i Żydów, a w propagandzie – jako języka przypisywanego wrogim, rzekomo „niższym rasowo” grupom społecznym, którego obecność w życiu publicznym uznawano za niepożądaną. Nazistowska interpretacja tego fragmentu sprowadzała esperanto do symbolu zagrożenia wewnętrznego oraz „żydowskiego żargonu”. Argument ten wykorzystywano w ulotkach stygmatyzujących ruch esperancki, materiałach partyjnych i wystąpieniach nazistów, co przyczyniło się do społecznej stygmatyzacji esperantystów i przygotowało grunt pod ich eliminację z życia publicznego. === Przykłady represji wobec esperantystów === Po 1933 roku represje wobec esperantystów przybrały charakter systemowy. Najpierw rozwiązano organizacje esperanckie lub zmuszono je do samolikwidacji, a ich majątek – biblioteki, archiwa i wydawnictwa – został skonfiskowany. Publikacje w języku esperanto objęto cenzurą, a nauczanie języka zostało zakazane. W drugiej połowie lat 30. esperanto zostało w praktyce całkowicie wyeliminowane z życia publicznego. Pomimo deklarowanego dopuszczenia jego używania „do celów prywatnych”, esperantyści byli aresztowani, kierowani do obozów koncentracyjnych lub oskarżani o działalność przeciwko państwu, co w większości przypadków prowadziło do ich śmierci. Jednakże, członkowie GEA próbowali się ratować, upolityczniając się i tworząc ruch „esperantystów-nazistów”; te starania nie przyniosły jednak oczekiwanego efektu, a w 1936 roku rozwiązano stowarzyszenie. Aktywni esperantyści byli inwigilowani przez aparat policyjny, a ich międzynarodowe kontakty traktowano jako potencjalną działalność szpiegowską. Szczególnie narażone były osoby związane wcześniej z ruchem robotniczym, pacyfistycznym lub socjalistycznym. W wielu przypadkach prowadziło to do aresztowań, przesłuchań, a następnie osadzenia w więzieniach lub obozach koncentracyjnych. Rzadko represjonowano esperantystów wyłącznie z powodu znajomości języka – jednak działalność esperancka często stanowiła jeden z elementów obciążających w aktach policyjnych. === Esperanckie grupy oporu w obozach koncentracyjnych – fakty czy legendy? === W literaturze esperanckiej oraz we wspomnieniach byłych więźniów obozów koncentracyjnych pojawiają się relacje dotyczące istnienia nieformalnych grup esperantystów działających w warunkach obozowych. Choć brak jest dokumentacji pozwalającej mówić o istnieniu sformalizowanych struktur organizacyjnych, dostępne źródła wskazują na funkcjonowanie konspiracyjnych sieci kontaktów opartych na wspólnej znajomości języka esperanto. Według relacji Franza Haiderera, austriackiego esperantysty i byłego więźnia, w obozach koncentracyjnych funkcjonowały grupy esperantystów liczące po kilkadziesiąt osób różnych narodowości. Grupy te prowadziły potajemną działalność edukacyjną – organizowano kursy językowe, sporządzano ręcznie pisane biuletyny informacyjne oraz wykorzystywano esperanto jako narzędzie wzajemnej komunikacji i solidarności. Działalność ta jest najlepiej udokumentowana w obozie koncentracyjnym [[w:KL Dachau|Dachau]], gdzie grupa licząca ok. 47 osób prowadziła kursy esperanta dla około 70 więźniów. O istnieniu podobnych form aktywności esperantystów wspomina się również w odniesieniu do innych obozów koncentracyjnych, m.in. Auschwitz i Buchenwaldu, jednak informacje te mają charakter fragmentaryczny i nie zostały dotąd potwierdzone w równie szczegółowych relacjach źródłowych. W historiografii obozowej również trudno jest znaleźć jakiekolwiek wzmianki na ten temat; przez lata historycy nie zwracali uwagi na problem. ==== Najbardziej heroiczne przykłady esperantystów w obozach ==== W kontekście obozów koncentracyjnych pojęcie heroizmu nie odnosi się do zorganizowanej walki zbrojnej, lecz do działań podejmowanych w warunkach stałego zagrożenia życia, polegających na podtrzymywaniu więzi międzyludzkich, przekazywaniu wiedzy oraz zachowaniu elementarnej godności ludzkiej. W tym sensie działalność esperantystów w obozach bywa interpretowana jako szczególna forma oporu kulturowego i moralnego. Jednym z nielicznych imiennie udokumentowanych przykładów takiej postawy jest działalność [[w:Albin Makowski|Albina Makowskiego]], opisana w opracowaniu Andrzeja Pettyna ''Skizo pri la Esperanto-movado en Pollando''. Makowski, polski esperantysta, prowadził tajne nauczanie języka esperanto w obozie koncentracyjnym Stutthof, a także – według relacji źródłowych – opracował podręcznik języka w całości z pamięci, w warunkach obozowych. Po zakończeniu wojny materiał ten miał być prezentowany w Muzeum Historycznym m.st. Warszawy jako świadectwo konspiracyjnej działalności kulturalnej więźniów, jednak jego obecne losy pozostają nieznane. Poza tym przypadkiem brak jest szczegółowo udokumentowanych biografii esperantystów, którzy prowadzili podobną działalność w obozach koncentracyjnych. Dostępne relacje wskazują jednak, że działania o charakterze edukacyjnym i solidarnościowym podejmowało więcej więźniów, których nazwiska i losy nie zostały utrwalone w źródłach. Zniszczenie dokumentacji obozowej, śmierć samych więźniów oraz marginalne zainteresowanie powojennej historiografii ruchem esperanckim sprawiły, że większość tych indywidualnych postaw pozostaje dziś anonimowa. === Przegląd najbardziej znanych ofiar === Represje nazistowskie wobec esperantystów objęły zarówno działaczy ruchu w Niemczech, jak i w krajach okupowanych. W wielu przypadkach prześladowania miały charakter pośredni – esperantyści byli represjonowani jako Żydzi, działacze lewicowi, intelektualiści lub przedstawiciele środowisk międzynarodowych – jednak działalność esperancka stanowiła dodatkowy czynnik obciążający w aktach ofiar. ==== Ofiary pochodzenia polskiego ==== Jedną z najbardziej znanych ofiar nazistowskich represji jest [[w:Lidia Zamenhof|Lidia Zamenhof]], córka twórcy języka esperanto. Była aktywną esperantystką, tłumaczką i działaczką ruchu, a także propagatorką [[w:bahaizm|bahaizm]]u. W czasie okupacji została uwięziona w getcie warszawskim, a następnie zamordowana w obozie zagłady Treblinka w 1942 roku. W tym samym obozie zginęła również jej siostra, Zofia Zamenhof, natomiast brat, Adam Zamenhof, lekarz okulista i esperantysta, został rozstrzelany przez Niemców w 1940 roku w Palmirach pod Warszawą. Zagładzie uległa także ich ciotka, Ida Zamenhof (Zimmermann). Wśród innych polskich esperantystów, którzy zginęli w wyniku represji nazistowskich, wymienia się m.in. [[w:Leo Belmont|Leo Belmonta]] (Leopolda Blumentala) – znanego pisarza i tłumacza esperanckiego, który zginął w getcie warszawskim, oraz [[w:Jakub Szapiro|Jakuba Szapiro]], znanego esperantystę białostockiego, zamordowanego w 1941 roku w lesie Pietrasze pod Białymstokiem. Do ofiar należał również Leopold Dreher (znany pod pseudonimem Leo Turno), autor podręczników do nauki esperanta, zamordowany przez Niemców we Lwowie, a także dziennikarz Edward Wiesenfeld, który zginął w niemieckim obozie koncentracyjnym. Wymienia się również Izraela Lejzerowicza, prezesa Polskiego Związku Esperantystów przed II wojną światową. ==== Ofiary z innych krajów europejskich ==== Represje dotknęły także esperantystów z Niemiec i innych krajów europejskich. Wielu niemieckich działaczy ruchu esperanckiego zostało aresztowanych, zmuszonych do zaprzestania działalności i/lub osadzonych w obozach koncentracyjnych. Część z nich zginęła w wyniku uwięzienia, chorób i egzekucji, choć pełna lista nazwisk nie zachowała się do dzisiaj. Wśród ofiar znajdowali się również esperantyści z Austrii, Czechosłowacji, Węgier, Jugosławii oraz innych państw okupowanych, deportowani do niemieckich obozów koncentracyjnych podczas wojny. W większości przypadków ich losy znane są jedynie fragmentarycznie, a działalność esperancka bywa jedynie wzmiankowana w relacjach obozowych jako jeden z elementów ich przedwojennej aktywności. Zestawienie to '''nie ma charakteru wyczerpującego'''. Zniszczenie dokumentacji oraz śmierć wielu działaczy sprawiły, że znaczna część ofiar nazistowskich represji wobec ruchu esperanckiego pozostaje dziś bezimienna. == Prześladowania esperantystów w ZSRR == === Początkowa akceptacja esperanta w latach 20. === Po rewolucji październikowej 1917 roku esperanto w Związku Radzieckim znalazło się początkowo w stosunkowo sprzyjającej sytuacji. W pierwszej dekadzie istnienia państwa radzieckiego władze wykazywały zainteresowanie ideami internacjonalizmu, które wpisywały się w oficjalną ideologię rewolucyjną. Język esperanto, jako narzędzie komunikacji ponadnarodowej, był postrzegany jako potencjalnie użyteczny środek kontaktu z zagranicznym ruchem robotniczym oraz międzynarodową lewicą. W latach 20. XX wieku w ZSRR działały liczne organizacje esperanckie, a język był wykorzystywany w publikacjach, korespondencji międzynarodowej oraz działalności edukacyjnej. Powstał Sowiecki Związek Esperantystów (SEU), który funkcjonował jako legalna organizacja społeczna, a jego członkowie brali udział w międzynarodowych kongresach i utrzymywali kontakty z zagranicznymi esperantystami. Esperanto pojawiało się także w prasie i literaturze, a w niektórych środowiskach było promowane jako „język proletariatu światowego”. W tym okresie język traktowano wręcz jako narzędzie postępowe i nowoczesne, odróżniające Związek Radziecki od państw kapitalistycznych. Nauczanie esperanta odbywało się w klubach robotniczych, domach kultury oraz w ramach działalności związków zawodowych. Część działaczy wierzyła, że esperanto stanie się oficjalnym językiem międzynarodowej rewolucji. Jednocześnie już w latach 20. pojawiały się pierwsze napięcia. Międzynarodowy charakter ruchu esperanckiego oraz niezależne kontakty z zagranicą budziły nieufność części aparatu partyjnego i służb bezpieczeństwa. Wraz z postępującą centralizacją władzy oraz zmianą kursu politycznego pod koniec dekady, wcześniejsza tolerancja zaczęła stopniowo ustępować miejsca podejrzliwości, która w kolejnych latach przerodziła się w otwarte represje. === Wielka czystka i represje wobec esperantystów === Radykalna zmiana sytuacji esperantystów w Związku Radzieckim nastąpiła w drugiej połowie lat 30. XX wieku, w okresie tzw. wielkiej czystki. Wraz z nasileniem represji politycznych aparat bezpieczeństwa rozpoczął masowe działania wymierzone w rzeczywistych i domniemanych przeciwników władzy, obejmujące również środowiska dotąd tolerowane lub wręcz wspierane. Esperantyści, jako grupa utrzymująca kontakty międzynarodowe i posługująca się językiem obcym, szybko znaleźli się w kręgu podejrzeń. Sowiecki Związek Esperantystów nie został formalnie rozwiązany, gdyż wymordowano prawie cały zarząd stowarzyszenia; nieoficjalnie jego działalność uznano za podejrzaną ideologicznie. Wielu działaczy ruchu zostało aresztowanych pod zarzutami działalności kontrrewolucyjnej, udziału w organizacjach antyradzieckich lub współpracy z zagranicznymi wywiadami. Represje miały charakter masowy i dotknęły zarówno znanych działaczy esperanckich, jak i zwykłych użytkowników języka. Aresztowania często kończyły się wyrokami długoletniego zesłania do łagrów lub egzekucjami. W licznych przypadkach jedynym „dowodem winy” była znajomość esperanta, korespondencja z zagranicą lub wcześniejsza działalność w legalnych organizacjach esperanckich z lat 20. W efekcie tych działań ruch esperancki w ZSRR został praktycznie całkowicie zlikwidowany. === Interpretacje działalności esperantystów jako „szpiegostwa” === Jednym z kluczowych mechanizmów represji wobec esperantystów w ZSRR było systematyczne przedstawianie ich działalności jako formy szpiegostwa. W oficjalnej narracji organów bezpieczeństwa międzynarodowy charakter ruchu esperanckiego interpretowano jako przykrywkę dla działalności wywiadowczej, a sam język postrzegano jako narzędzie tajnej komunikacji. W relacjach archiwalnych oraz wspomnieniowych pojawiają się powtarzalne formuły oskarżeń, w których esperantystów określano jako członków „międzynarodowej organizacji szpiegowskiej ukrywającej się na terytorium ZSRR pod nazwą Sowiecki Związek Esperantystów”. Tego rodzaju sformułowania poprzedzały wydanie wyroków śmierci lub decyzje o zesłaniu do łagrów. Kontakty z zagranicznymi esperantystami, udział w kongresach oraz wymiana korespondencji, które w latach 20. były postrzegane jako element internacjonalizmu, w latach 30. stały się podstawą oskarżeń o zdradę i działalność antyradziecką. Esperantystów oskarżano m.in. o lojalność wobec obcych państw zamiast wobec ZSRR. W latach 1937–1938 represje wobec esperantystów w ZSRR osiągnęły skalę masową. Z relacji jedynego świadka, któremu udało się opuścić Związek Radziecki – rosyjskiego aktora [[w:Nikolaj Rytkow|Nikolaja Rytkova]] – oraz z późniejszych świadectw i publikacji wynika, że aparat bezpieczeństwa uznał środowisko esperanckie za jedną z grup przeznaczonych do fizycznej likwidacji. W oficjalnej propagandzie okresu wielkiej czystki środki masowego przekazu były wypełnione informacjami o „wrogach ludu”, „zagranicznych szpiegach” i „międzynarodowych spiskach”. W tym kontekście utrwaliło się przekonanie, że sama znajomość języka esperanto oraz kontakty z zagranicą stanowią dowód działalności wywrotowej. Esperantyści byli zaliczani do kategorii osób „społecznie obcych” lub „posiadających kontakty międzynarodowe”, co w praktyce oznaczało aresztowanie. Aresztowania odbywały się bez publicznych komunikatów i bez podania przyczyn. Członkowie Sowieckiego Związku Esperantystów znikali kolejno, począwszy od kierownictwa organizacji. Według relacji Rytkova niemal cały aparat SEU został zlikwidowany – część działaczy rozstrzelano, inni zginęli w łagrach lub podczas zesłania na Syberię i Kołymę. Szczególnym przykładem jest postać [[w:Ernest Drezen|Ernesta Drezena]] – radzieckiego inżyniera, jednego z czołowych działaczy ruchu esperanckiego w ZSRR i wcześniejszego zwolennika władzy radzieckiej. Jego aresztowanie i egzekucja stały się symbolicznym momentem zerwania państwa z ruchem esperanckim oraz sygnałem, że nawet lojalność wobec systemu nie chroni przed represjami. === Przegląd najbardziej znanych ofiar === Ofiarami represji stalinowskich padli niemal wszyscy czołowi działacze ruchu esperanckiego w ZSRR. Najbardziej symboliczną postacią był [[w:Ernest Drezen|Ernest Drezen]] – inżynier, terminolog i jeden z głównych organizatorów sowieckiego ruchu esperanckiego. Przez wiele lat lojalny wobec władzy radzieckiej, współtworzył projekty normalizacji terminologii technicznej i utrzymywał kontakty z międzynarodowymi instytucjami naukowymi. Został aresztowany w 1937 roku i według relacji świadków rozstrzelany jeszcze w tym samym roku. Wśród ofiar znaleźli się również m.in.: * [[w:Władimir Warankin|Władimir Warankin]] – autor prac teoretycznych i powieści ''Metropoliteno'', który zaginął po aresztowaniu; * [[w:Nikołaj Niekrasow|Nikołaj Niekrasow]] – dziennikarz i autor literatury esperanckiej, który zginął w obozie karnym; * Viktor Kolczinskij – działacz ruchu, który zmarł w młodym wieku po aresztowaniu; * Volodymyr Kuzmycz – ukraiński pisarz tworzący również w języku esperanto, zmarły w więzieniu w Ałma-Acie w 1943 roku. Represje objęły także esperantystów z republik bałtyckich oraz emigrantów politycznych z innych krajów, m.in. Węgrów, Niemców i Austriaków. Wielu z nich zostało deportowanych do łagrów lub rozstrzelanych. Dokładna liczba ofiar nie jest znana – według relacji Rytkova aresztowano dziesiątki tysięcy sowieckich esperantystów, z czego tysiące nie przeżyły zesłania. == Dziedzictwo i pamięć == === Ruch esperanta po II wojnie światowej === Po zakończeniu II wojny światowej ruch esperancki znalazł się w sytuacji głębokiej odbudowy. Represje nazistowskie i stalinowskie doprowadziły do fizycznej eliminacji znacznej części przedwojennych działaczy, zerwania ciągłości organizacyjnej oraz zniszczenia infrastruktury ruchu w wielu krajach Europy. Odbudowa następowała nierównomiernie i w odmiennych warunkach politycznych, zależnych od podziału kontynentu na strefy wpływów. W krajach Europy Zachodniej oraz w państwach neutralnych ruch esperancki stopniowo reaktywował się już w drugiej połowie lat 40. XX wieku. Wznowiono działalność stowarzyszeń krajowych, reaktywowano kongresy międzynarodowe oraz podjęto próby dokumentowania strat poniesionych w okresie wojny. Szczególną rolę odegrały organizacje międzynarodowe, które starały się przywrócić zerwane więzi pomiędzy środowiskami esperanckimi różnych państw. W Polsce esperantyści, choć musieli budować wszystko od nowa, bardzo szybko zreaktywowali się. W 1944 roku, w „wyzwolonym” przez Armię Czerwoną Lublinie już istniała grupa esperancka. W 1945 roku reaktywował się Polski Związek Esperantystów (pod ówczesną nazwą '''Związek Esperantystów w Polsce'''; '''Asocio de Esperantistoj en Pollando'''). W 1946 roku wznowiono wydawanie czasopisma ''Pola Esperantisto'', a rok później Mieczysław Sygnarski wydał swój ''Kurs elementarny esperanto, pomocniczego języka międzynarodowego w 15 lekcjach''. Potem ruch zamroził się z przyczyn politycznych, ale nigdy go nie zakazano w pełni. Esperantyści później mieli szerokie pole działania za sprawą małej stabilizacji, które wykorzystywali przy współpracy z władzą komunistyczną. === Wpływ represji na rozwój języka i społeczności === Represje wobec esperantystów wywarły długotrwały wpływ zarówno na rozwój samego języka, jak i na strukturę oraz tożsamość społeczności esperanckiej. Fizyczna eliminacja znacznej części działaczy, przerwanie ciągłości organizacyjnej oraz zniszczenie archiwów i dorobku wydawniczego doprowadzały do poważnego osłabienia ruchu. Szczególnie dotkliwe konsekwencje miały represje w ZSRR, gdzie niemal całkowicie zlikwidowano esperantystów, zwłaszcza elitę intelektualną. Spowodowało to utratę potencjału twórczego w zakresie literatury, terminologii naukowej i działalności organizacyjnej. W wielu krajach Europy Środkowo-Wschodniej powojenny ruch musiał być odbudowywany bez naturalnej ciągłości pokoleniowej, często przez osoby, które dopiero po wojnie zetknęły się z esperantem. Doświadczenia represji wpłynęły również na zmianę charakteru ruchu esperanckiego. W okresie powojennym coraz większy nacisk kładziono na humanistyczne i pacyfistyczne aspekty idei esperanta, traktując je jako przeciwwagę dla nacjonalizmów i ideologii totalitarnych. Pamięć o ofiarach nazizmu i stalinizmu stała się istotnym elementem narracji historycznej ruchu, obecnym w publikacjach, wspomnieniach oraz działalności edukacyjnej. Jednocześnie represje przyczyniły się do większej ostrożności w kontaktach międzynarodowych oraz do częściowej depolityzacji ruchu. W wielu krajach działalność esperancka koncentrowała się na aspektach kulturalnych, językowych i edukacyjnych, unikając otwartego zaangażowania ideologicznego. Paradoksalnie jednak, mimo prób marginalizacji i wielokrotnych uderzeń ze strony władzy, esperanto przetrwało jako żywy język międzynarodowy, a doświadczenia XX wieku stały się jednym z fundamentów jego współczesnej tożsamości. == Bibliografia i źródła == * Ulrich Lins, ''Niebezpieczny język'', dostęp elektroniczny pod adresem: http://www.esperanto.cba.pl/images/lins.pdf * Andrzej Pettyn, ''Skizo pri la Esperanto-movado en Pollando'', Warszawa, 1978, dostęp elektroniczny pod adresem: https://esperanto.pl/archiwum/archiwum-PZE/assets/dokumenty/Skizo%20pri%20la%20Esperanto-movado%20en%20Pollando.pdf * artykuł Franza Haiderera pt. ''Esperanto en koncentrejo'', dostęp elektroniczny pod adresem: http://esperanto.china.org.cn/EL/EL/ElPopolaCxinio/98-7-4.html == Dodatek == Chętnych do pogłębienia tematu zaprasza się do lektury dodatku pt. ''Prześladowania esperantystów w cesarskiej Japonii''. Oddzieliłem go od głównej strony, link znajduje się tutaj: → [[/Dodatek|Dodatek do książki]] 34dww4p9uzv3i1dpao96xz09cahd61b 4 63291 538496 538495 2026-03-29T12:31:07Z Persino 2851 /* {{Code|CzyTakSilnik(args,funkcja)}} */ 538496 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{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}}}}). 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, ich klucze pomniejsza 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 dzialaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , o wartości: {{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 żadnych z tych wartości, to wtedy jest transformiowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jeddnej z dwoch specjalnie przygotowanych funkcji. === {{Code|p["CzyTakCiąg"](frame)}} === === {{Code|p.CzyTak(...)}} === == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 553tqst5bi12veybul5gtq8581e0qub 538497 538496 2026-03-29T12:32:55Z Persino 2851 /* {{Code|CzyTakSilnik(args,funkcja)}} */ 538497 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{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}}}}). 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 wartości: {{Code|1}} i {{Code|2}}), ich klucze pomniejsza 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 dzialaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , o wartości: {{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 żadnych z tych wartości, to wtedy jest transformiowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jeddnej z dwoch specjalnie przygotowanych funkcji. === {{Code|p["CzyTakCiąg"](frame)}} === === {{Code|p.CzyTak(...)}} === == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 5ow98f61hbtxprcpseiymev4o21lmb9 538498 538497 2026-03-29T12:40:23Z Persino 2851 /* {{Code|CzyTakSilnik(args,funkcja)}} */ 538498 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{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}}}}). 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 wartości: {{Code|1}} i {{Code|2}}), ich klucze pomniejsza 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}}}} , o wartości: {{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 żadnych 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"> 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, dziecko, w kodzie {{Lpg|Lua}} w {{Lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. === {{Code|p["CzyTakCiąg"](frame)}} === === {{Code|p.CzyTak(...)}} === == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ilviao597tzy7x9cwleayj6hgo1f47m 538499 538498 2026-03-29T12:41:05Z Persino 2851 /* {{Code|CzyTakSilnik(args,funkcja)}} */ 538499 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{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}}}}). 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 wartości: {{Code|1}} i {{Code|2}}), ich klucze pomniejsza 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}}}} , o wartości: {{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 żadnych 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"> 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, dziecko, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. === {{Code|p["CzyTakCiąg"](frame)}} === === {{Code|p.CzyTak(...)}} === == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> dzu5yd5xftdhv8hbjy4dkoc104chm20 538500 538499 2026-03-29T12:43:00Z Persino 2851 /* {{Code|CzyTakSilnik(args,funkcja)}} */ 538500 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{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}}}}). 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 wartości: {{Code|1}} i {{Code|2}}), ich klucze pomniejsza 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}}}} , o wartości: {{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 żadnych 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, dziecko, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. === {{Code|p["CzyTakCiąg"](frame)}} === === {{Code|p.CzyTak(...)}} === == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 1w4dksc5e79qes3hm60850gndx8mg3k 538501 538500 2026-03-29T13:21:51Z Persino 2851 /* {{Code|CzyTakSilnik(args,funkcja)}} */ 538501 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{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}}}}). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. === {{Code|p["CzyTakCiąg"](frame)}} === === {{Code|p.CzyTak(...)}} === == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> aituwlxq6jn7rd7c2uqwx62cqoo7n2c 538502 538501 2026-03-29T13:24:20Z Persino 2851 /* Funkcje prawdy i fałszu */ 538502 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. === {{Code|p["CzyTakCiąg"](frame)}} === === {{Code|p.CzyTak(...)}} === == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 7pw0xv0giv3mezxa98ujkkwpzuhe8ee 538504 538502 2026-03-29T13:41:02Z Persino 2851 /* {{Code|p["CzyTakCiąg"](frame)}} */ 538504 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. === {{Code|p["CzyTakCiąg"](...)}} === === {{Code|p.CzyTak(...)}} === == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> nvycuh2tpv33dtucqdwuk5mvnr91q82 538505 538504 2026-03-29T14:03:21Z Persino 2851 /* {{Code|p["CzyTakCiąg"](...)}} */ 538505 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. === {{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. <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ść }} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| }} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo, że funkcja {{Code|{{sr|#p.CzyTak(...)}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="mediawiki"> 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="mediawiki"> 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(...)}} === == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 5yokgxboy15opzzvvsm2jyjsx50y9zg 538506 538505 2026-03-29T14:04:10Z Persino 2851 /* {{Code|p["CzyTakCiąg"](...)}} */ 538506 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. === {{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. <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ść }} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| }} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo, że funkcja {{Code|{{sr|#p.CzyTak(...)}}}} 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(...)}} === == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 6f55yavqse2652nxppa61yuvl81wjkd 538507 538506 2026-03-29T14:06:51Z Persino 2851 /* {{Code|p["CzyTakCiąg"](...)}} */ 538507 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. === {{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. <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ść }} </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| }} </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(...)}} === == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> nljo0xz62mznf24bmyn6bbcn2c91gts 538508 538507 2026-03-29T14:11:58Z Persino 2851 /* {{Code|p["CzyTakCiąg"](...)}} */ 538508 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. === {{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ść }} </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| }} </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(...)}} === == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> r7wf5v8pch1fij9ozdmgu3gxl7zvj4f 538509 538508 2026-03-29T14:19:04Z Persino 2851 /* {{Code|CzyTakSilnik(args,funkcja)}} */ 538509 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4}} </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. === {{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ść }} </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| }} </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(...)}} === == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 9euh9ll7upc9j6pt0m6ja9jit263lbc 538510 538509 2026-03-29T14:27:31Z Persino 2851 /* {{Code|CzyTakSilnik(args,funkcja)}} */ 538510 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4}} </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"] }, 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ść }} </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| }} </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(...)}} === == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 9ckjlzxd1760jvzrak9b8h84aa3hagn 538511 538510 2026-03-29T14:28:07Z Persino 2851 /* {{Code|CzyTakSilnik(args,funkcja)}} */ 538511 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4}} </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", }, 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ść }} </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| }} </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(...)}} === == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> k0qxqguepp39w1vso8gevpx8gsr4g7z 538512 538511 2026-03-29T15:09:24Z Persino 2851 /* {{Code|p.CzyTak(...)}} */ 538512 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4}} </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", }, 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ść }} </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| }} </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ść }} </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| }} </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. 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. 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)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 01pckyfjaef6wrxp7g4a3kyjchdjicm 538513 538512 2026-03-29T15:13:45Z Persino 2851 /* {{Code|p.CzyTak(...)}} */ 538513 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4}} </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", }, 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ść }} </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| }} </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ść }} </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| }} </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|}} </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)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 4hs3pgzh9u6ss6sblxkuwc8j8pq9lqx 538518 538513 2026-03-29T15:20:10Z Persino 2851 /* Funkcje prawdy i fałszu */ 538518 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> cbwwn9sqvdzjwxxkuq3ougti2r6u1x5 538528 538518 2026-03-29T15:45:02Z Persino 2851 /* {{Code|p.PobierzFrameEwentualnieParent(frame)}} */ 538528 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy 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 parametrowi 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); .... end; </syntaxhighlight> === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 3qw0ov5n1in0t64k6ysg0h7oh709x2u 538529 538528 2026-03-29T15:54:13Z Persino 2851 /* {{Code|p.PobierzFrameEwentualnieParent(frame)}} */ 538529 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy 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 parametrowi 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); .... 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> === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 9jrsdtupt1zo2lfidxfbbantcjkovbe 538530 538529 2026-03-29T15:54:53Z Persino 2851 /* {{Code|p.PobierzFrameEwentualnieParent(frame)}} */ 538530 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy 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 parametrowi 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); .... 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> === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 7a2fqrrj1jc6cligwaug6rl9j46ah5i 538531 538530 2026-03-29T15:55:38Z Persino 2851 /* {{Code|p.PobierzFrameEwentualnieParent(frame)}} */ 538531 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy 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 parametrowi 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); .... 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> === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> h9phjx7m9vp607pgi4rr557pertjrn1 538532 538531 2026-03-29T16:03:59Z Persino 2851 /* {{Code|p.PobierzFrameEwentualnieParent(frame)}} */ 538532 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy 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 parametrowi 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 niedokodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy rramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 7gcxoaqdu8jfafj8ynzf49udmgynavd 538533 538532 2026-03-29T16:05:14Z Persino 2851 /* {{Code|p.PobierzFrameEwentualnieParent(frame)}} */ 538533 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy 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 parametrowi 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 niedokodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> lc8l56dzww9pglobagbmgkbe71orrgj 538534 538533 2026-03-29T16:12:17Z Persino 2851 /* {{Code|p.PobierzFrameEwentualnieParent(frame)}} */ 538534 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy 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 parametrowi 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 niedokodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 1ablutc4koyg464q2eni9dpa20m2iez 538535 538534 2026-03-29T16:35:01Z Persino 2851 /* Funkcje prawdy i fałszu */ 538535 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy 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 parametrowi 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 niedokodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 3khwljc4nc5k8j772bof95tk6vzzmr5 538536 538535 2026-03-29T16:42:57Z Persino 2851 /* {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} */ 538536 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy 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 parametrowi 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 niedokodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy 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> Tą funkcją można sterować ze strony ramki tym właśnie parametrowi 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 1ah8g5yh4owbjfcdjgzjhnrd4oxyoqo 538537 538536 2026-03-29T16:44:01Z Persino 2851 /* {{Code|p.PobierzFrameEwentualnieParent(frame)}} */ 538537 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy 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 parametrowi o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy 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> Tą funkcją można sterować ze strony ramki tym właśnie parametrowi 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> egennnzi8v282sfdtc9mjmqg7dzhwio 538538 538537 2026-03-29T16:48:37Z Persino 2851 /* {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} */ 538538 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy 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 parametrowi o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy 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> Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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 parametrowi 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 3u0g42oypj5sn1w1lwjpdci0mqtz0a3 538540 538538 2026-03-29T17:11:39Z Persino 2851 /* Funkcje parametrów */ 538540 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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> Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> jgs1ld18udgkmcrtayq0rwvcl4ajehh 538541 538540 2026-03-29T18:37:08Z Persino 2851 /* {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} */ 538541 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{Code|p.PobierzParametryRamki(frame)}} === === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 9z45l2e4ldw7ra3tgasjzaxxxpu72iy 538542 538541 2026-03-29T19:16:54Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538542 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{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> === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ka3efui6dv6nmioxkt4x5w9qg1w9srk 538545 538542 2026-03-29T20:10:51Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538545 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{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 tablica, 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;}}. Równie dobrze możemy wywołać to 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 wyniki uzyskuje się w następującym wywołaniu: <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łej nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; 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 noetablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> b27049mdtpfthb41uzy9g8g2m5elbr7 538546 538545 2026-03-29T20:21:03Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538546 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{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 tablica, 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;}}. Równie dobrze możemy wywołać to 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 wyniki uzyskuje się w następującym wywołaniu: <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 noetablicowe, 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: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Wtedy ta zmienna 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)}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym nazem zwraca wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> nctv0b2s972171blg8ktgarmodl6uw1 538547 538546 2026-03-29T20:23:44Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538547 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{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 nie posiada nazwy zmiennej tablicowej, ani w ogóle o nazwie {{Code|args}}. Równie dobrze możemy wywołać to 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 wyniki uzyskuje się w następującym wywołaniu: <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 noetablicowe, 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: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Wtedy ta zmienna 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)}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym nazem zwraca wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> sjs7z032hfbo9gnxlfa86vy5vy02fp9 538548 538547 2026-03-29T20:28:58Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538548 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{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 nie posiada nazwy zmiennej tablicowej, ani w ogóle o nazwie {{Code|args}}. Równie dobrze możemy wywołać to 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 wyniki uzyskuje się w następującym wywołaniu: <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 noetablicowe, 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: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Wtedy ta zmienna 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)}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym nazem zwraca wartość {{Code|nil}}. 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, to wtedy ta wartość jest {{Code|frame["tekst"]}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 1iypod38k52rac6jzram7297e3gbvdi 538549 538548 2026-03-29T20:29:29Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538549 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{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 nie posiada nazwy zmiennej tablicowej, ani w ogóle o nazwie {{Code|args}}. Równie dobrze możemy wywołać to 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 wyniki uzyskuje się w następującym wywołaniu: <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 noetablicowe, 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: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Wtedy ta zmienna 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)}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym nazem zwraca wartość {{Code|nil}}. 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, to wtedy ta wartość jest {{Code|frame["tekst"]}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> das2788epxwrcponnd9hvxpywlf27zp 538550 538549 2026-03-29T20:39:52Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538550 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{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 nie posiada nazwy zmiennej tablicowej, ani w ogóle, o nazwie {{Code|args}}. Równie dobrze możemy wywołać to 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 wyniki uzyskuje się w następującym wywołaniu: <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 noetablicowe, 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: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Wtedy ta zmienna 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)}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym nazem zwraca wartość {{Code|nil}}. 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, to wtedy ta wartość jest {{Code|frame["tekst"]}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> fdzk9zba1dug34myl3ukzx4jp4x6g5g 538551 538550 2026-03-29T20:45:42Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538551 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{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 nie posiada nazwy zmiennej tablicowej, ani w ogóle, o nazwie {{Code|args}}. Równie dobrze możemy wywołać to 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 wyniki uzyskuje się w następującym wywołaniu: <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 noetablicowe, 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: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Wtedy ta zmienna 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)}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym nazem zwraca wartość {{Code|nil}}. 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, to wtedy ta wartość jest {{Code|frame["tekst"]}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> gbd1x7bxy4qhy5xp7tofjjwznpr9d4i 538552 538551 2026-03-29T20:49:10Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538552 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{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 fubkcji, co pokażemy poniżej. Równie dobrze możemy wywołać to 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 wyniki uzyskuje się w następującym wywołaniu: <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 noetablicowe, 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: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Wtedy ta zmienna 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)}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym nazem zwraca wartość {{Code|nil}}. 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, to wtedy ta wartość jest {{Code|frame["tekst"]}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> tmddixu5egmx0e30lue0ptn0nksllmm 538553 538552 2026-03-29T20:56:29Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538553 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{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 fubkcji, co pokażemy poniżej. Równie dobrze możemy wywołać to 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 wyniki uzyskuje się w następującym wywołaniu: <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 noetablicowe, 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: <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)}}}}, 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, to wtedy ta wartość jest {{Code|frame["tekst"]}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> jxgjw4qhrgdy54xyjke863st29djgpa 538554 538553 2026-03-29T20:57:45Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538554 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{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 fubkcji, co pokażemy poniżej. Równie dobrze możemy wywołać to 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 wyniki uzyskuje się w następującym wywołaniu: <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 noetablicowe, 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: <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, to wtedy ta wartość jest {{Code|frame["tekst"]}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 2i2ismjthgbrpllyziy1xyg2e1lwbxx 538555 538554 2026-03-30T04:42:35Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538555 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{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> A pod wieloma kluczami: <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 tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest 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}}. 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, to wtedy ta wartość jest {{Code|frame["tekst"]}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> aywvvankm6ypyiiv4msddcalqic7scd 538556 538555 2026-03-30T04:46:50Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538556 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{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, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A pod wieloma kluczami: <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 tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest 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}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> obupeyr70c1yu8f1xa5q2qsr80q6rq5 538557 538556 2026-03-30T04:48:44Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538557 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{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, 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 tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest 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}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> duudkod5f05vixzmihx1b1h6y4vmf0y 538558 538557 2026-03-30T04:53:55Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538558 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{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, 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 tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest 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)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> nvfeexef4v6onzowy2v2ysqsqdbtjty 538559 538558 2026-03-30T05:03:36Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538559 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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ć, 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 tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. === {{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, 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)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ju6gkbh4xrt7bf9v58m7lldposz0omk 538560 538559 2026-03-30T05:22:57Z Persino 2851 /* {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} */ 538560 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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 args=parametry_modul.PobierzArgsParametry(frame,true); </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, 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)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> bwxb9zekr0drmranc8qlwjmhk05b24k 538561 538560 2026-03-30T05:26:13Z Persino 2851 /* {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} */ 538561 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją 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> === {{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, 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)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> sycwvwnfaks524tf5fr9qedeauqknxx 538562 538561 2026-03-30T05:35:22Z Persino 2851 /* {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} */ 538562 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musimieć wartość {{Code|true}}, a wtedy 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, 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)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 0ej1v6a1ne0lf3m5fk2jsw7tokovu6w 538563 538562 2026-03-30T05:36:37Z Persino 2851 /* {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} */ 538563 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy 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, 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)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> oehbovf6lwa5b9d2rqevx910a76uff6 538564 538563 2026-03-30T05:38:02Z Persino 2851 /* {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} */ 538564 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, 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)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> hr59536hl2opue0kz4ue81t855qok7w 538565 538564 2026-03-30T05:39:49Z Persino 2851 /* {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} */ 538565 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, 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)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 72shvuykui67lsc412ek6mtjfmwhiay 538569 538565 2026-03-30T06:33:14Z Persino 2851 /* {{Code|p.PobierzParametryRamki(frame)}} */ 538569 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> q804wno07n7xm0m6zn07jq0w3atkg53 538570 538569 2026-03-30T06:45:11Z Persino 2851 /* {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} */ 538570 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. 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 funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> lhnxpwlaj3gyxj7xc9almho0q7u7pik 538571 538570 2026-03-30T06:47:22Z Persino 2851 /* {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} */ 538571 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to można ją umieścić w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwraca ją w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 6zn4y5xjhzs7qlfiqrd5dceko92xoml 538572 538571 2026-03-30T06:50:33Z Persino 2851 /* {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} */ 538572 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje funkcję {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}} 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}}. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 5qpafrucmvggxaw4mu0r6u34kphe6va 538573 538572 2026-03-30T06:53:03Z Persino 2851 /* {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} */ 538573 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> l35hys2uw5tuj4jbkzisu24jknk26a4 538574 538573 2026-03-30T06:53:41Z Persino 2851 /* {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} */ 538574 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. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> bgnrh15xy6td23ybxjqusaznnckmklb 538576 538574 2026-03-30T10:08:45Z Persino 2851 538576 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wzystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślni są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma zamieniać ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu wykrywać, do zamieniania, ma tylko odstępy,a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie w rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tą funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tą funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === === {{Code|p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame)}} === == Funkcje wartości logicznej == === {{Code|p.And(frame)}} === === {{Code|p.Or(frame)}} === === {{Code|p.Not(frame)}} === == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === == Metafunkcje i metatabele == === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === == Iteratory == === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu}} === == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowyh. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bwzwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ale tak nie jest, ona wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednoostkach bezwzględnych na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością z dwóch liczb jest: {{Code|3}}. Wartością z dwóch liczb jest: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 09cn1h9b96p2pio7fq1edgkrekagib0 104 63351 538514 2026-03-29T15:17:17Z Igor123121 34732 nowe hasło 538514 wikitext text/x-wiki [[Plik:Lampada a petrolio.jpg|mały]] [[Plik:Muzeum Regionalne PTTK w Gorlicach 058.JPG|mały]] Lampa naftowa to urządzenie oświetleniowe wykorzystujące naftę jako paliwo, którego powstanie w połowie XIX wieku zrewolucjonizowało życie codzienne oraz wpłynęło na rozwój przemysłu naftowego na świecie. Wynalazek ten jest nierozerwalnie związany z działalnością polskiego farmaceuty i przedsiębiorcy Ignacego Łukasiewicza. == Proces destylacji ropy i konstrukcja urządzenia == W latach 1852–1853 Ignacy Łukasiewicz wraz z Janem Zehem, pracując w lwowskiej aptece „Pod Złotą Gwiazdą”, przeprowadzili badania nad frakcjonowaną destylacją ropy naftowej. Celem eksperymentów było uzyskanie paliwa bezpieczniejszego i wydajniejszego niż stosowane dotychczas oleje roślinne czy tran. W wyniku tych prac otrzymano naftę świetlną. Ponieważ dostępne wówczas lampy olejowe nie były dostosowane do spalania nafty (dochodziło do wybuchów lub nadmiernego dymienia), Łukasiewicz we współpracy z lwowskim blacharzem Adamem Bratkowskim skonstruował prototyp nowej lampy. Urządzenie posiadało grubościenny zbiornik na paliwo, palnik dostosowany do właściwości nafty oraz szklany kominek, który poprawiał ciąg powietrza i stabilizował płomień. == Historyczne zastosowanie i rozwój przemysłu == Pierwsze publiczne zastosowanie lampy naftowej miało miejsce 31 lipca 1853 roku, kiedy to oświetlono nią salę operacyjną w szpitalu na lwowskim Łyczakowie podczas nocnej operacji. Wydarzenie to uznaje się za narodziny nowoczesnego przemysłu naftowego. W 1854 roku Łukasiewicz założył w Bóbrce koło Krosna pierwszą na świecie kopalnię ropy naftowej (istniejącą do dziś jako Muzeum Przemysłu Naftowego i Gazowniczego), a w 1856 roku pierwszą rafinerię w Ulaszowicach. Lampa naftowa szybko zyskała popularność na całym świecie, stając się podstawowym źródłem światła w domach, fabrykach i na statkach, aż do czasu upowszechnienia się oświetlenia elektrycznego na przełomie XIX i XX wieku. rttklz6c07g40gmx6ynr95luuyabrhb 104 63352 538515 2026-03-29T15:17:57Z Igor123121 34732 nowe hasło 538515 wikitext text/x-wiki [[Plik:Silicon crystal 4 inch interferences 640x480.jpg|mały|Monokryształ krzemu otrzymany metodą Czochralskiego]] [[Plik:Czochralski Process PL.svg|mały|Zasada metody Czochralskiego]] Metoda Czochralskiego to technika wytwarzania monokryształów (kryształów o jednolitej, uporządkowanej strukturze wewnętrznej), opracowana w 1916 roku przez polskiego chemika i metalurga Jana Czochralskiego. Odkrycie to jest uznawane za jedno z najważniejszych w historii współczesnej nauki, ponieważ umożliwiło rozwój elektroniki i technologii półprzewodnikowych. == Mechanizm procesu krystalizacji == Proces ten, określany fachowo jako wyciąganie kryształów, polega na kontrolowanym przejściu substancji ze stanu ciekłego w stały. W specjalnym urządzeniu umieszcza się tygiel z roztopionym materiałem (np. krzemem). Do powierzchni cieczy wprowadza się mały, wzorcowy kryształ, zwany zarodkiem. Zarodek jest następnie powoli i jednostajnie podnoszony przy jednoczesnym ruchu obrotowym. Podczas wyciągania, płynny materiał przylega do zarodka i krzepnie, zachowując jego strukturę krystaliczną. W wyniku tego procesu powstaje duży, jednorodny kryształ o kształcie walca, zwany wlewkiem monokrystalicznym. == Zastosowanie w przemyśle i elektronice == Metoda Czochralskiego jest obecnie najpowszechniej stosowaną techniką produkcji krzemu monokrystalicznego na świecie. Materiał ten stanowi podstawę do wytwarzania układów scalonych, mikroprocesorów oraz tranzystorów, które są elementami składowymi komputerów, smartfonów i innych urządzeń cyfrowych. Bez tej technologii niemożliwa byłaby miniaturyzacja elektroniki. Metoda ta znajduje również zastosowanie w produkcji kryształów dla laserów, medycyny oraz w wytwarzaniu nowoczesnych ogniw fotowoltaicznych wykorzystywanych w panelach słonecznych. Szacuje się, że ponad 90% urządzeń elektronicznych wykorzystuje materiały wyprodukowane za pomocą techniki opracowanej przez polskiego uczonego. lqcx7qqqhvtc8fyafsgkg5c3cbebbni 104 63353 538516 2026-03-29T15:19:02Z Igor123121 34732 nowe hasło 538516 wikitext text/x-wiki [[Plik:MINE DETECTOR IN NORTH AFRICA 1942.jpg|mały]] [[Plik:Infantry mine-detecting team in training at Studland in Dorset, 7 May 1943. H29724.jpg|mały]] Ręczny wykrywacz min, znany również jako wykrywacz typu Mine Detector Polish Mark I, to przenośne urządzenie elektroniczne służące do wykrywania przedmiotów metalowych ukrytych pod powierzchnią ziemi. Zostało ono opracowane w 1941 roku przez polskiego inżyniera i porucznika wojsk łączności, Józefa Kosackiego, podczas jego pobytu na emigracji w Wielkiej Brytanii w trakcie II wojny światowej. == Zasada działania i innowacyjność projektu == Urządzenie Kosackiego oparte było na wykorzystaniu zjawiska indukcji elektromagnetycznej. Składało się z dwóch głównych elementów: talerzowej sondy (cewki) umieszczonej na długim drążku oraz plecaka z układem elektronicznym i bateriami. Gdy sonda przemieszczała się nad metalowym przedmiotem (np. korpusem miny), dochodziło do zmiany pola magnetycznego, co generowało sygnał dźwiękowy słyszalny w słuchawkach operatora. Kluczową innowacją Kosackiego była wysoka czułość wykrywacza przy jednoczesnym zachowaniu niskiej wagi (ok. 14 kg) i prostoty obsługi, co pozwalało na jego masowe wykorzystanie w warunkach polowych przez pojedynczego żołnierza. == Zastosowanie bojowe i znaczenie historyczne == Józef Kosacki nie opatentował swojego wynalazku, przekazując go bezpłatnie Armii Brytyjskiej jako wkład w wysiłek wojenny sojuszników. Pierwsze masowe użycie polskiego wykrywacza min miało miejsce w 1942 roku podczas bitwy pod El Alamein w Afryce Północnej. Urządzenia te pozwoliły saperom na szybkie i sprawne unieszkodliwienie niemieckich pól minowych, co znacząco przyspieszyło ofensywę wojsk alianckich i przyczyniło się do ich zwycięstwa. Wykrywacz min konstrukcji Kosackiego był produkowany w tysiącach egzemplarzy i stał się standardowym wyposażeniem wielu armii świata na kolejne dekady. Podstawowa koncepcja tego urządzenia jest wykorzystywana do dziś w nowoczesnych wykrywaczach min oraz profesjonalnych wykrywaczach metali stosowanych przez geologów i archeologów. bk81akjlhp5lg3p5cf88taj7vmwnqbh 104 63354 538517 2026-03-29T15:20:00Z Igor123121 34732 nowe hasło 538517 wikitext text/x-wiki [[Plik:Windscreen Wiper.gif|mały]] [[Plik:Mazda Roadpacer in the Mazda-Museum Augsburg 02.jpg|mały]] Wycieraczki do szyb to mechaniczne urządzenia służące do usuwania wody, śniegu i zanieczyszczeń z przedniej szyby pojazdu w celu zapewnienia widoczności kierowcy. Choć nad podobnymi rozwiązaniami pracowało wielu konstruktorów na początku XX wieku, to kluczowy wkład w ich udoskonalenie i upowszechnienie miał polski pianista i kompozytor Józef Hofmann. == Geneza wynalazku i inspiracja mechaniczna == Józef Hofmann, oprócz kariery muzycznej, pasjonował się techniką i był autorem kilkudziesięciu patentów z zakresu mechaniki. Inspiracją dla jego projektu wycieraczek był mechanizm działania metronomu – urządzenia wahadłowego używanego przez muzyków do odmierzania temtu. Hofmann przeniósł zasadę rytmicznego ruchu wahadłowego na ramię wycieraczki, co pozwoliło na sprawne i powtarzalne oczyszczanie powierzchni szyby. Pierwsze wycieraczki konstrukcji Hofmanna były montowane w seryjnie produkowanych samochodach marki Ford, co zapoczątkowało ich masowe zastosowanie w przemyśle motoryzacyjnym. == Rozwój techniczny i współczesne standardy == Wczesne modele wycieraczek były napędzane ręcznie przez kierowcę lub pasażera za pomocą specjalnej dźwigni. Wynalazek Hofmanna oraz innowacje innych konstruktorów (takich jak Mary Anderson, która opatentowała pierwszy ręczny system w 1903 r.) doprowadziły do powstania wycieraczek napędzanych silnikiem elektrycznym. Współczesne systemy wycieraczek są wyposażone w gumowe pióra o wysokiej elastyczności, spryskiwacze oraz czujniki deszczu, które automatycznie regulują częstotliwość ruchu ramion w zależności od intensywności opadów. Wynalazek ten stał się nieodzownym elementem bezpieczeństwa czynnego w każdym pojeździe mechanicznym, samolocie oraz na statkach. f4v1wz1iqohmbs2noshd8amkvjpcu0d 104 63355 538519 2026-03-29T15:20:29Z Igor123121 34732 nowe hasło 538519 wikitext text/x-wiki [[Plik:NIJ LVLIIIA Kogelvrij vest, BA8001.jpg|mały]] [[Plik:Bulletproof vest J1.jpg|mały]] Kamizelka kuloodporna to element indywidualnego opancerzenia służący do ochrony tułowia przed pociskami z broni palnej oraz odłamkami. Wynalazek ten, w swojej nowoczesnej, elastycznej formie, powstał na przełomie XIX i XX wieku dzięki pracom dwóch Polaków: Jana Szczepanika oraz Kazimierza Żeglenia. Ich odkrycia położyły fundament pod współczesne technologie ochrony balistycznej. == Wykorzystanie jedwabiu i technologia splotu == Kluczem do stworzenia skutecznej ochrony było zastosowanie wielowarstwowej tkaniny jedwabnej. Kazimierz Żegleń, polski zakonnik mieszkający w Chicago, przeprowadził liczne eksperymenty, które dowiodły, że gęsty splot naturalnego jedwabiu potrafi zatrzymać pociski z ówczesnej broni krótkiej. Jednak produkcja ręczna była mało wydajna. Problem ten rozwiązał Jan Szczepanik, wybitny wynalazca zwany „polskim Edisonem”, który opracował automatyczny warsztat tkacki do produkcji tkanin kuloodpornych. Kamizelki Szczepanika i Żeglenia składały się z wielu warstw materiału, które pochłaniały energię kinetyczną pocisku, zapobiegając jego penetracji w głąb ciała. == Sukcesy i uznanie międzynarodowe == Wynalazek zyskał światową sławę w 1902 roku, kiedy to powóz hiszpańskiego króla Alfonsa XIII został wyłożony tkaniną kuloodporną projektu Szczepanika. Dzięki temu monarcha ocalał podczas zamachu bombowego w Madrycie. Za ten czyn Szczepanik otrzymał od króla wysokie odznaczenie państwowe. Polskie kamizelki były również testowane przez policję w USA oraz służby ochrony monarchów europejskich (m.in. cara Mikołaja II). Choć współczesne kamizelki kuloodporne wykorzystują materiały syntetyczne, takie jak Kevlar, to koncepcja wielowarstwowej, wytrzymałej tkaniny jako bariery dla pocisków wywodzi się bezpośrednio z projektów opracowanych przez polskich inżynierów ponad sto lat temu. kip2wwtev8xi7ia42ogowljg3xc9xxs 104 63356 538520 2026-03-29T15:21:26Z Igor123121 34732 nowe hasło 538520 wikitext text/x-wiki [[Plik:Poliodrops.jpg|mały|Szczepienie doustne przeciw Polio]] Poliomyelitis, znane potocznie jako choroba Heinego-Medina, to wirusowa choroba zakaźna, która w pierwszej połowie XX wieku wywoływała ogólnoświatowe epidemie prowadzące do porażenia mięśni i trwałej niepełnosprawności, szczególnie wśród dzieci. Przełom w walce z tym zagrożeniem nastąpił dzięki pracom polsko-amerykańskiego wirusologa i lekarza, Hilarego Koprowskiego, który opracował pierwszą na świecie skuteczną szczepionkę doustną. == Opracowanie atenuowanego wirusa i pierwsze testy == Hilary Koprowski rozpoczął badania nad szczepionką pod koniec lat 40. XX wieku w laboratoriach firmy Lederle w USA. Jego metoda opierała się na wykorzystaniu żywych, ale osłabionych (atenuowanych) wirusów, które po podaniu doustnym stymulowały układ odpornościowy do wytworzenia przeciwciał bez wywoływania objawów choroby. W 1948 roku naukowiec jako pierwszy przetestował prototypowy preparat na samym sobie, a 27 lutego 1950 roku przeprowadził pierwsze masowe badanie kliniczne. Było to wydarzenie o znaczeniu historycznym, które wyprzedziło o kilka lat wdrożenie szczepionki inaktywowanej (podawanej w zastrzyku) autorstwa Jonasa Salka oraz doustnej szczepionki Alberta Sabina. == Kampania w Polsce i znaczenie dla zdrowia publicznego == W 1958 roku Koprowski przeprowadził masową akcję szczepień w Kongu Belgijskim, co potwierdziło skuteczność jego preparatu w warunkach epidemicznych. Kluczowym momentem dla Polski był przełom lat 1959 i 1960, kiedy to dzięki osobistemu zaangażowaniu wynalazcy do kraju trafiło bezpłatnie 9 milionów dawek szczepionki. Pozwoliło to na przeprowadzenie powszechnej kampanii szczepień, która doprowadziła do niemal całkowitego wyeliminowania zachorowań na polio w Polsce w ciągu zaledwie dwóch lat. Metoda doustna (OPV) stała się w kolejnych dekadach fundamentem globalnego programu eradykacji, czyli całkowitego usunięcia wirusa z populacji ludzkiej, realizowanego przez Światową Organizację Zdrowia (WHO). Odkrycie polskiego uczonego położyło podwaliny pod nowoczesną immunologię i profilaktykę chorób wirusowych. hk1ht20gv1uo6m89027u9h2cae8bif0 104 63357 538522 2026-03-29T15:24:16Z Igor123121 34732 nowe hasło 538522 wikitext text/x-wiki {{Wikipedia|Stroje ludowe w Polsce|Stroje ludowe w Polsce}} [[Plik:Young Polish women in traditional clothing from Chruszczyna Mała village.jpg|mały|Portret kobiety i dziewczyny w odświętnych strojach ludowych]] [[Plik:Awalerowie z Krzczonowa.jpg|mały|Kawalerowie w strojach krzczonowskich (początek XX wieku)]] Polskie stroje ludowe to tradycyjne ubiory noszone przez mieszkańców wsi w okresach świątecznych i uroczystych. Proces ich kształtowania się trwał od XVIII do początków XX wieku, osiągając pełnię rozwoju po uwłaszczeniu chłopów w XIX wieku, kiedy to wzrost zamożności wiejskiej ludności pozwolił na stosowanie droższych materiałów i bogatszych zdobień. Stroje te pełnią funkcję manifestacji przynależności regionalnej, lokalnej tożsamości oraz statusu społecznego właściciela. == Zróżnicowanie regionalne i charakterystyka wybranych strojów == W Polsce wyodrębnia się kilkadziesiąt odmian strojów ludowych, które różnią się krojem, kolorystyką oraz technikami zdobniczymi. Do najbardziej rozpoznawalnych należą: * Strój krakowski – uznawany za polski strój narodowy. Męski składa się z białej sukmany, czerwonej rogatywki z pawimi piórami oraz kaftana zwanego бряnką z mosiężnymi brzękadłami. Kobiecy wyróżnia się kwiecistą spódnicą, białym haftowanym gorsetem oraz koralami. * Strój łowicki – charakteryzuje się zastosowaniem tkanin w kolorowe pasy (pasiaków). Początkowo dominowała czerwień, którą w późniejszym okresie zastąpiły odcienie zieleni, fioletu i niebieskiego. Haft łowicki (płaski i cieniowany) przedstawia motywy roślinne, głównie róże i bratki. * Strój góralski (podhalański) – dostosowany do warunków klimatycznych Karpat. Mężczyźni noszą spodnie z białego sukna (portki) z parzenicami, białe koszule oraz skórzane kierpce i kapelusze z muszelkami. Kobiety wkładają kwieciste spódnice, aksamitne gorsety i ręcznie haftowane bluzki. * Strój kurpiowski – występuje w odmianie Puszczy Zielonej i Białej. Cechą charakterystyczną są czółka (nakrycia głowy dziewcząt) oraz bogate hafty o motywach geometrycznych i roślinnych. == Materiały i techniki wykonania == Tradycyjne stroje ludowe wykonywano z surowców naturalnych dostępnych w gospodarstwie domowym lub lokalnym rzemiośle. Podstawę stanowiły tkaniny lniane i konopne oraz wełniane sukna. Do zdobienia używano haftów (m.in. dziurkowanego, krzyżykowego, płaskiego), koronek, aplikacji z aksamitu, tasiemek oraz guzików. Bardzo istotnym elementem zdobniczym były pasy – skórzane u górali czy jedwabne w strojach mieszczańskich. Stroje te są obecnie przedmiotem badań etnograficznych oraz podlegają ochronie jako element niematerialnego dziedzictwa kulturowego. Ich współczesne wykorzystanie ogranicza się głównie do występów zespołów folklorystycznych oraz uroczystości religijnych i państwowych. == Znaczenie społeczne i symbolika == Ubiór ludowy stanowił system znaków informujących o stanie cywilnym, wieku oraz majętności osoby. Odmienne nakrycia głowy przysługiwały pannom (wianki, opaski), a inne mężatkom (czepce, chusty wiązane w czub). Kolorystyka i ilość haftu świadczyły o zamożności gospodarstwa. Obecnie polskie stroje ludowe są chronione i popularyzowane przez instytucje kultury, m.in. Muzeum Etnograficzne w Warszawie oraz liczne skanseny regionalne. Są one również inspirowane w nowoczesnym wzornictwie przemysłowym (tzw. etnodesign). fq8hsxwpumt57ft8nyap21q2obd4xyl 538523 538522 2026-03-29T15:24:32Z Igor123121 34732 538523 wikitext text/x-wiki {{Wikipedia|Stroje ludowe w Polsce|Stroje ludowe w Polsce}} [[Plik:Young Polish women in traditional clothing from Chruszczyna Mała village.jpg|mały|Portret kobiety i dziewczyny w odświętnych strojach ludowych]] [[Plik:Kawalerowie z Krzczonowa.jpg|mały|Kawalerowie w strojach krzczonowskich (początek XX wieku)]] Polskie stroje ludowe to tradycyjne ubiory noszone przez mieszkańców wsi w okresach świątecznych i uroczystych. Proces ich kształtowania się trwał od XVIII do początków XX wieku, osiągając pełnię rozwoju po uwłaszczeniu chłopów w XIX wieku, kiedy to wzrost zamożności wiejskiej ludności pozwolił na stosowanie droższych materiałów i bogatszych zdobień. Stroje te pełnią funkcję manifestacji przynależności regionalnej, lokalnej tożsamości oraz statusu społecznego właściciela. == Zróżnicowanie regionalne i charakterystyka wybranych strojów == W Polsce wyodrębnia się kilkadziesiąt odmian strojów ludowych, które różnią się krojem, kolorystyką oraz technikami zdobniczymi. Do najbardziej rozpoznawalnych należą: * Strój krakowski – uznawany za polski strój narodowy. Męski składa się z białej sukmany, czerwonej rogatywki z pawimi piórami oraz kaftana zwanego бряnką z mosiężnymi brzękadłami. Kobiecy wyróżnia się kwiecistą spódnicą, białym haftowanym gorsetem oraz koralami. * Strój łowicki – charakteryzuje się zastosowaniem tkanin w kolorowe pasy (pasiaków). Początkowo dominowała czerwień, którą w późniejszym okresie zastąpiły odcienie zieleni, fioletu i niebieskiego. Haft łowicki (płaski i cieniowany) przedstawia motywy roślinne, głównie róże i bratki. * Strój góralski (podhalański) – dostosowany do warunków klimatycznych Karpat. Mężczyźni noszą spodnie z białego sukna (portki) z parzenicami, białe koszule oraz skórzane kierpce i kapelusze z muszelkami. Kobiety wkładają kwieciste spódnice, aksamitne gorsety i ręcznie haftowane bluzki. * Strój kurpiowski – występuje w odmianie Puszczy Zielonej i Białej. Cechą charakterystyczną są czółka (nakrycia głowy dziewcząt) oraz bogate hafty o motywach geometrycznych i roślinnych. == Materiały i techniki wykonania == Tradycyjne stroje ludowe wykonywano z surowców naturalnych dostępnych w gospodarstwie domowym lub lokalnym rzemiośle. Podstawę stanowiły tkaniny lniane i konopne oraz wełniane sukna. Do zdobienia używano haftów (m.in. dziurkowanego, krzyżykowego, płaskiego), koronek, aplikacji z aksamitu, tasiemek oraz guzików. Bardzo istotnym elementem zdobniczym były pasy – skórzane u górali czy jedwabne w strojach mieszczańskich. Stroje te są obecnie przedmiotem badań etnograficznych oraz podlegają ochronie jako element niematerialnego dziedzictwa kulturowego. Ich współczesne wykorzystanie ogranicza się głównie do występów zespołów folklorystycznych oraz uroczystości religijnych i państwowych. == Znaczenie społeczne i symbolika == Ubiór ludowy stanowił system znaków informujących o stanie cywilnym, wieku oraz majętności osoby. Odmienne nakrycia głowy przysługiwały pannom (wianki, opaski), a inne mężatkom (czepce, chusty wiązane w czub). Kolorystyka i ilość haftu świadczyły o zamożności gospodarstwa. Obecnie polskie stroje ludowe są chronione i popularyzowane przez instytucje kultury, m.in. Muzeum Etnograficzne w Warszawie oraz liczne skanseny regionalne. Są one również inspirowane w nowoczesnym wzornictwie przemysłowym (tzw. etnodesign). ihvhzuo2ueejn518tkr6cwq5kuqujo7 104 63358 538524 2026-03-29T15:25:24Z Igor123121 34732 nowe hasło 538524 wikitext text/x-wiki {{Wikipedia|Kuchnia polska|Kuchnia polska}} [[Plik:Pierogi in Warsaw, 2019.jpg|mały|Pierogi – potrawa typowa dla kuchni polskiej]] [[Plik:Schabowy Gniezno.jpg|mały|Kotlet schabowy z ugotowanymi ziemniakami]] Kuchnia polska to tradycyjny sposób przygotowywania potraw, ukształtowany na przestrzeni wieków pod wpływem warunków klimatycznych, rolniczego charakteru państwa oraz przenikania się kultur narodów zamieszkujących dawną Rzeczpospolitą. Charakteryzuje się ona dużą kalorycznością, częstym wykorzystaniem zbóż, mięs (zwłaszcza wieprzowiny i dziczyzny), ryb słodkowodnych oraz owoców runa leśnego i warzyw uprawnych. == Tradycyjne produkty i surowce == Podstawę polskiego jadłospisu od średniowiecza stanowiły produkty zbożowe, w tym chleb żytni, kasze (m.in. gryczana i jęczmienna) oraz mączne mączne takie jak kluski i pierogi. Ważnym elementem są przetwory kiszone, zwłaszcza kapusta i ogórki, które dzięki procesowi fermentacji mlekowej zapewniały dostęp do witamin w okresie zimowym. W tradycyjnym gospodarstwie domowym kluczową rolę odgrywały również nabiał, miód oraz grzyby. Polska słynie z produkcji wędlin, w tym szlachetnych odmian szynek i kiełbas (np. myśliwska, krakowska), poddawanych procesom wędzenia w dymie z drewna drzew liściastych. == Charakterystyka głównych potraw i zup == Polska kuchnia wyróżnia się bogactwem zup, które często stanowią samodzielne danie. Do najbardziej znanych należą: * Żurek – zupa na bazie zakwasu z mąki żytniej, podawana z białą kiełbasą i jajkiem. * Barszcz czerwony – czysty wywar z buraków ćwikłowych, tradycyjnie serwowany z uszkami. * Bigos – potrawa jednogarnkowa z kiszonej i świeżej kapusty, z dodatkiem różnych gatunków mięs, wędlin, grzybów i przypraw. * Pierogi – ciasto wypełnione farszem (m.in. z twarogu i ziemniaków – tzw. ruskie, mięsa, kapusty z grzybami lub owoców sezonowych). * Kotlet schabowy – panierowany płat mięsa wieprzowego, który stał się jednym z najpopularniejszych dań obiadowych w XX wieku. Wpływy kulturowe i ochrona prawna produktów Współczesny kształt kuchni polskiej jest wynikiem historycznych wpływów kuchni żydowskiej, litewskiej, niemieckiej, francuskiej oraz włoskiej (wprowadzenie włoszczyzny, czyli warzyw korzeniowych). Wiele tradycyjnych polskich wyrobów podlega obecnie ochronie prawnej w ramach systemów jakości Unii Europejskiej. Produkty takie jak oscypek (ser owczy z Podhala), rogale świętomarcińskie czy olej rydzowy posiadają certyfikaty Chronionej Nazwy Pochodzenia lub Chronionego Oznaczenia Geograficznego. Nadzór nad jakością handlową artykułów rolno-spożywczych sprawuje w Polsce wyspecjalizowana inspekcja państwowa (IJHARS). Polskie tradycje kulinarne są również elementem promocji kraju za granicą jako istotna składowa turystyki kulturowej. jru8gh5vvgiidnv3aggcbisu2mcnk1o 538525 538524 2026-03-29T15:25:38Z Igor123121 34732 /* Charakterystyka głównych potraw i zup */ 538525 wikitext text/x-wiki {{Wikipedia|Kuchnia polska|Kuchnia polska}} [[Plik:Pierogi in Warsaw, 2019.jpg|mały|Pierogi – potrawa typowa dla kuchni polskiej]] [[Plik:Schabowy Gniezno.jpg|mały|Kotlet schabowy z ugotowanymi ziemniakami]] Kuchnia polska to tradycyjny sposób przygotowywania potraw, ukształtowany na przestrzeni wieków pod wpływem warunków klimatycznych, rolniczego charakteru państwa oraz przenikania się kultur narodów zamieszkujących dawną Rzeczpospolitą. Charakteryzuje się ona dużą kalorycznością, częstym wykorzystaniem zbóż, mięs (zwłaszcza wieprzowiny i dziczyzny), ryb słodkowodnych oraz owoców runa leśnego i warzyw uprawnych. == Tradycyjne produkty i surowce == Podstawę polskiego jadłospisu od średniowiecza stanowiły produkty zbożowe, w tym chleb żytni, kasze (m.in. gryczana i jęczmienna) oraz mączne mączne takie jak kluski i pierogi. Ważnym elementem są przetwory kiszone, zwłaszcza kapusta i ogórki, które dzięki procesowi fermentacji mlekowej zapewniały dostęp do witamin w okresie zimowym. W tradycyjnym gospodarstwie domowym kluczową rolę odgrywały również nabiał, miód oraz grzyby. Polska słynie z produkcji wędlin, w tym szlachetnych odmian szynek i kiełbas (np. myśliwska, krakowska), poddawanych procesom wędzenia w dymie z drewna drzew liściastych. == Charakterystyka głównych potraw i zup == Polska kuchnia wyróżnia się bogactwem zup, które często stanowią samodzielne danie. Do najbardziej znanych należą: * Żurek – zupa na bazie zakwasu z mąki żytniej, podawana z białą kiełbasą i jajkiem. * Barszcz czerwony – czysty wywar z buraków ćwikłowych, tradycyjnie serwowany z uszkami. * Bigos – potrawa jednogarnkowa z kiszonej i świeżej kapusty, z dodatkiem różnych gatunków mięs, wędlin, grzybów i przypraw. * Pierogi – ciasto wypełnione farszem (m.in. z twarogu i ziemniaków – tzw. ruskie, mięsa, kapusty z grzybami lub owoców sezonowych). * Kotlet schabowy – panierowany płat mięsa wieprzowego, który stał się jednym z najpopularniejszych dań obiadowych w XX wieku. == Wpływy kulturowe i ochrona prawna produktów == Współczesny kształt kuchni polskiej jest wynikiem historycznych wpływów kuchni żydowskiej, litewskiej, niemieckiej, francuskiej oraz włoskiej (wprowadzenie włoszczyzny, czyli warzyw korzeniowych). Wiele tradycyjnych polskich wyrobów podlega obecnie ochronie prawnej w ramach systemów jakości Unii Europejskiej. Produkty takie jak oscypek (ser owczy z Podhala), rogale świętomarcińskie czy olej rydzowy posiadają certyfikaty Chronionej Nazwy Pochodzenia lub Chronionego Oznaczenia Geograficznego. Nadzór nad jakością handlową artykułów rolno-spożywczych sprawuje w Polsce wyspecjalizowana inspekcja państwowa (IJHARS). Polskie tradycje kulinarne są również elementem promocji kraju za granicą jako istotna składowa turystyki kulturowej. i23nvixr0n6wgfhg8qha3ronlukdoro 104 63359 538526 2026-03-29T15:26:40Z Igor123121 34732 nowe hasło 538526 wikitext text/x-wiki Powiedzenia i przesądy stanowią istotny element niematerialnego dziedzictwa kulturowego Polski. Są one zapisem dawnych wierzeń, doświadczeń historycznych oraz obserwacji przyrodniczych, przekazywanym z pokolenia na pokolenie drogą ustną. W polskiej kulturze ludowej i współczesnej pełnią funkcję regulacyjną, porządkującą relacje międzyludzkie oraz sposób postrzegania zjawisk losowych. == Charakterystyka i geneza polskich przesądów == Większość polskich przesądów wywodzi się z dawnych wierzeń słowiańskich oraz średniowiecznych zwyczajów. Do najbardziej rozpowszechnionych należą te dotyczące zapewnienia pomyślności lub unikania nieszczęścia. Przykłady obejmują: * Witanie się przez próg – uznawane za przynoszące pecha, co historycznie wiązało się z przekonaniem, że próg jest granicą oddzielającą bezpieczny dom od niebezpiecznego świata zewnętrznego. * Czarny kot – przebiegający drogę, traktowany jest jako zwiastun pecha, co stanowi pozostałość dawnych uprzedzeń wobec zwierząt przypisywanych siłom nieczystym. * Rozsypanie soli – uznawane za zapowiedź kłótni, co wynika z wysokiej wartości ekonomicznej soli w dawnych wiekach. * Spotkanie kominiarza – tradycyjnie uznawane za oznakę szczęścia; zwyczaj nakazuje wówczas złapanie się za guzik, co ma zapewnić pomyślność. == Przysłowia jako zapis mądrości ludowej i historycznej == Polskie przysłowia często pełnią funkcję dydaktyczną lub opisują cykliczność natury. Znaczna ich część jest związana z kalendarzem liturgicznym i rolniczym (np. „Święta Barbara po lodzie, Boże Narodzenie po wodzie”). Istnieją również powiedzenia o podłożu historycznym, odzwierciedlające realia dawnych epok, jak popularne „Za króla Sasa jedz, pij i popuszczaj pasa”, odnoszące się do czasów panowania dynastii Wettynów. Inne, jak „Mądry Polak po szkodzie”, stanowią zbiorową refleksję nad narodowymi cechami charakteru i doświadczeniami politycznymi. == Badania i ochrona niematerialnego dziedzictwa == Powiedzenia i przysłowia są przedmiotem systematycznych badań językoznawców oraz etnografów. Największy zbiór tego typu tekstów zawiera opracowanie „Nowa księga przysłów i wyrażeń przysłowiowych polskich”, redagowane przez zespół pod kierunkiem prof. Juliana Krzyżanowskiego. Dokumentowanie i ochrona tych form wyrazu wpisuje się w ramy wyznaczone przez Konwencję UNESCO w sprawie ochrony niematerialnego dziedzictwa kulturowego z 2003 roku, którą Polska ratyfikowała. Instytucje takie jak Instytut Języka Polskiego PAN czuwają nad zachowaniem tych form jako istotnego składnika tożsamości narodowej i bogactwa języka polskiego. 01fkjc79exbauwq3v42ytct0x8ju49d 104 63360 538527 2026-03-29T15:26:55Z Igor123121 34732 nowe hasło 538527 wikitext text/x-wiki Sztuka ludowa w Polsce to dziedzina twórczości artystycznej rozwijana przez lokalne społeczności, głównie wiejskie. Obejmuje ona wytwory rzemiosła, plastykę obrzędową oraz architekturę, które łączą walory estetyczne z funkcjami praktycznymi i religijnymi. Największy rozwój tradycyjnych form ludowych nastąpił w XIX wieku, co wiązało się ze wzrostem zamożności wsi po uwłaszczeniu chłopów. == Dziedziny plastyki ludowej i rzemiosła == Polska sztuka ludowa wyróżnia się różnorodnością technik i motywów zdobniczych. Do kluczowych dziedzin należy rzeźba w drewnie, tradycyjnie koncentrująca się na tematyce sakralnej (np. wizerunki Chrystusa Frasobliwego). Ważnym elementem dekoracyjnym wnętrz wiejskich było malarstwo na szkle, rozwinięte szczególnie na Podhalu, oraz wycinankarstwo. Wycinanki, wykonywane z kolorowego papieru przy użyciu nożyc do strzyżenia owiec, posiadają odmienną stylistykę w zależności od regionu: w okolicach Łowicza dominują wielobarwne motywy roślinne, natomiast na Kurpiach jednobarwne formy geometryczne i sylwetki ptaków. Istotną rolę odgrywa również garncarstwo oraz plecionkarstwo, które dostarczały przedmiotów użytkowych o unikalnym wzornictwie. == Plastyka obrzędowa i tradycje sezonowe == Ważną częścią twórczości ludowej jest plastyka związana z kalendarzem agrarnym i liturgicznym. Do najbardziej rozpoznawalnych wytworów należą pisanki – jajka zdobione różnymi technikami (batikową, rytowniczą lub oklejaniem) w okresie Wielkanocy. Innym przykładem są pająki, czyli misterne konstrukcje ze słomy, nici i bibuły, zawieszane pod sufitami w okresie Bożego Narodzenia. Unikalnym zjawiskiem w skali światowej są szopki krakowskie, charakteryzujące się wieżową konstrukcją i bogatą kolorystyką nawiązującą do architektury zabytków Krakowa. W 2018 roku tradycja ta została wpisana na Listę reprezentatywną niematerialnego dziedzictwa kulturowego ludzkości UNESCO. == Instytucjonalna ochrona dziedzictwa == Współczesna sztuka ludowa podlega systemowej ochronie i dokumentacji. Nadzór merytoryczny nad zbiorami sprawują muzea etnograficzne oraz skanseny (parki etnograficzne), które gromadzą i konserwują materialne dowody kultury wiejskiej. Wspieraniem autentycznej twórczości zajmuje się m.in. Stowarzyszenie Twórców Ludowych oraz Narodowy Instytut Kultury i Dziedzictwa Wsi. Wybrane umiejętności i tradycje, takie jak koronczarstwo koniakowskie, są wpisane na Krajową listę niematerialnego dziedzictwa kulturowego, co zapewnia ich ochronę oraz ułatwia przekaz wiedzy kolejnym pokoleniom w ramach państwowej polityki kulturalnej. qetl9j4fvq3vhtzu56ixvzy44p0ifi9